
# -*- encoding: utf-8 -*-

import re
from apina import Apina
import artlista as l
import parser.parser as parser
from tekstiapu import *
from apufunktiot import *
import action

# Sisäänkirjautuminen
def login():
    # eri tiedostoon, ettei uploadata tunnuksia vahingossa
    import eiupata
    return eiupata.login()

arr = { "a": "adjektiivi", "adv" : "adverbi", "num" : "numeraalit", "pref" : "prefiksit", "pron" : "pronominit", "s": "substantiivi", "v": "verbi" }

knimi = u"Suomi"
klyhenne = u"fi"

# sanaluokat, joihin johdos lisätään ts. johtosanan luokka
# MUUTA
#slnimet = [ u"Verbi" ]

slnimet = [ u"Adjektiivi", u"Numeraali", u"Postpositio", u"Prepositio", u"Substantiivi", "Interjektio" ]
#slnimet = [ u"Substantiivi" ]

# johdetun sanan luokka
# MUUTA
#sllyhenne = u"v" # ÄLÄ TEE TÄLLÄ SKRIPTILLÄ!!
#sllyhenne = u"adv"
sllyhenne = u"s"
#sllyhenne = u"adv"

# lisätäänkö johdokset-mallineeseen vai [[]]-merkkeihin
on_johdosmalline = True 

jluokka = arr[sllyhenne] + "t"

ttnro = 2
#ttnro = 70
tiedosto = u"scripts/johdokset/mp/" + unicode(ttnro) + "/" + sllyhenne + "/yhdistetty.out.txt"
#tiedosto = u"mallineparseri/viiva-adverbit.txt"
#logi = u"logit/fi-lisää-johdos2-" + unicode(ttnro) + "-" + sllyhenne
logi = u"logit/fi-lisää-johdos2-40-49-" + sllyhenne
#tiedosto = u"johdos-itse.txt"


# Listan luominen.
def init(wl):
    lst = None
    lst = l.Uppilista2(tiedosto)
    lst.set_log_prefix(logi)
#    lst.set_log_prefix(u"logit/fi-lisää-johdos-itse")
#    lst = l.Testilista(u"testilistat", [u"luoda"])
#    lst.set_log_prefix(u"logit/fi-lisää-johdos2-verbi-testi") # MUUTA

    print u"Tiedosto: " + tiedosto
    print u"Logi: " + logi
    return lst




def lajittele(lista):
    # lajittelee ja poistaa tuplat
    lista.sort()
    l2 = []
    ed = None
    for e in lista:
        if e != ed:
            l2.append(e)
        ed = e
    return l2




rex = r"{{johdokset\|fi\|([^|]+)\|"

def sort_key(a):
    global arr, rex
    m = re.match(rex, a)
    if m:
        print "index: {}".format(arr[m.group(1)])
        return arr[m.group(1)]
    return -1

def sort_key_rivit(a):
    m = re.match(r"^\* *([a-z]+) *:", a)
    if m:
        return m.group(1)
    return sort_key(a)

def tee_johdoslista(on_johdosmalline, lista):
    if on_johdosmalline:
        return u"{{johdokset|" + klyhenne + "|" + sllyhenne + "|" + ("|".join(lista)) + u"}}"
    else:
        return u"*" + jluokka + ": [[" + ("]], [[".join(lista)) + u"]]"
        
# Artikkelin editoiminen.
#  art  (uppilista.Sivu)   artikkeli
def edit(art, oma):
    global knimi, slnimi, sllyhenne, jluokka

    if art.is_new():
        return u"Sivua ei ole"

    try:
        w = parser.WiktSivu(art.wtxt)
    except parser.LiianMontaOsiotaException as e:
        return u"Liian monta osiota: {}".format(e)
    except e:
        return u"Virhe parsittaessa: {}".format(e)

    if not w:
        return u"Ei parsittava"

    kieli = w.kieliosio(u"" + knimi + u"")
    if not kieli:
        return u"Ei " + knimi + u"-osiota"
    sanaluokat = []

    for sl in slnimet:
        sanaluokat += kieli.sanaluokat(sl)

#    sanaluokat += kieli.sanaluokat(u"Adjektiivi")
#    sanaluokat += kieli.sanaluokat(u"Substantiivi")


    if len(sanaluokat) == 0:
        return u"Ei sopivaa osiota"
    if len(sanaluokat) > 1:
        return u"Liian monta osiota"

    sanalk = sanaluokat[0]

    slnimi = sanalk.nimi
    
    johdokset = None
    liittyvat = sanalk.slaliosio(u"Liittyvät sanat")
    if liittyvat:
        johdokset = liittyvat.slaliosio(u"Johdokset")
    

    art.set_summary_prefix(u"/*" + knimi + u"*/: " + slnimi + ": ")
#    print u"OMA: " + unicode(oma)
    omat = oma.split(";")

    # huom. jos liittyvät sanat osiota ei ole, se lisätään samalla kun johdokset alla
    if liittyvat:

        for oma in omat:
            m = re.search(u"[[|{]" + oma + u"[]|}]", liittyvat.tekstiosa() or u"")
            if m:
                print u"Sisältää jo johdoksen, poistetaan."
                tekstiosa = liittyvat.tekstiosa()

                tekstiosa = poista_osiosta(tekstiosa, oma)

                liittyvat.set_tekstiosa(tekstiosa)
                #            art.set_pause("Vanhan poisto")
                art.add_note(u"Johdos on jo liittyvissä sanoissa")

        
    if johdokset:
        omat2 = []
        for oma in omat:
            print u"etsitään: " + oma
            m = re.search(u"[[|{]" + oma + u"[]|}]", johdokset.tekstiosa() or u"")
            if m:
                art.add_note(u"Johdos on jo johdoksissa: {}".format(oma))
            else:
                print u"ei löydy"
                omat2.append(oma)

        if omat2 == []:
            return u"Kaikki johdokset on jo johdoksissa"

        omat = omat2
        omat.sort()

        tekstiosa = johdokset.tekstiosa() or u""
        if len(tekstiosa) > 0 and tekstiosa[-1] != '\n': tekstiosa += "\n"
        m = re.search(r"{{johdokset\|"+ klyhenne + r"\|" + sllyhenne + r"\|([^}]+)}}", tekstiosa)
        m2 = re.search(r"\* *" + jluokka + "t?: *([^\n]*)\n", tekstiosa)

        l = []
        if m:
            alku, _, loppu = pilko(tekstiosa, m.start(0), m.end(0))
            _, luettelo, _ = pilko(tekstiosa, m.start(1), m.end(1));
            tekstiosa = alku + loppu
            print "m:luettelo: " + luettelo
            l = luettelo.split(u"|")



        if m2:
            if m2.group(0).find(";") != -1:
                print u"KAKSOISPISTE luettelossa"
                art.pause()
            alku, _, loppu = pilko(tekstiosa, m2.start(0), m2.end(0))
            _, luettelo, _ = pilko(tekstiosa, m2.start(1), m2.end(1));
            tekstiosa = alku + loppu
            print "m2:luettelo: " + luettelo
            luettelo = re.sub(" *\[\[|\]\] *", "", m2.group(1))
            print "luettelo: " + luettelo
            l += luettelo.split(u",")


        if m or m2:
            l+= omat
            l2 = []
            for a in l:
                print u"a: {}".format(a)
                l2.append(u"{}".format(a))
                    
            l = lajittele(l2)
            l = l2
            tekstiosa = tekstiosa.strip() + u"\n" + tee_johdoslista(on_johdosmalline, l) + u"\n"
            johdokset.set_tekstiosa(tekstiosa)
            art.add_info(u"+johdos: [[" + ("]], [[".join(omat)) + "]]")

            print u"Uusi tekstiosa: " + tekstiosa
            art.add_note(u"Lisätty johdos olemassa olevaan")

        else:
            print u"ei ennestään"
            tekstiosa = tekstiosa.strip() + u"\n" + tee_johdoslista(on_johdosmalline, omat)
            r = tekstiosa.split("\n")
            r.sort(key=sort_key_rivit)
            tekstiosa = u"\n".join(r)
            johdokset.set_tekstiosa(tekstiosa)
            omat = lajittele(omat)
            art.add_info(u"+johdos: [[" + ("]], [[".join(omat)) + "]]")

            art.add_note(u"Lisätty johdos uuteen")
#            art.set_pause() # väliaikainen


    else:
        tekstiosa = u"\n" + tee_johdoslista(on_johdosmalline, omat)
 
        johdokset = sanalk.lisaa_oikeaan_paikkaan(parser.Osio(u"Johdokset"))
        johdokset.set_tekstiosa(tekstiosa)
        art.add_info(u"+johdos: [[" + "]], [[".join(omat) + "]]")

        art.add_note(u"Lisätty Johdokset-osio")

    
    if art.on_muuttunut():
        return action.Edit(re.sub(u"\n\n\n+", "\n\n", w.teksti()))

    return u"Ei muutettu"

